package com.interview;

import org.junit.Test;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class HuaweiTest {


    private final static int BASE = 16;
    private static Map<Character, Integer> map = new HashMap<Character, Integer>()
    {{
        put('0', 0);
        put('1', 1);
        put('2', 2);
        put('3', 3);
        put('4', 4);
        put('5', 5);
        put('6', 6);
        put('7', 7);
        put('8', 8);
        put('9', 9);
        put('A', 10);
        put('B', 11);
        put('C', 12);
        put('D', 13);
        put('E', 14);
        put('F', 15);
        put('a', 10);
        put('b', 11);
        put('c', 12);
        put('d', 13);
        put('e', 14);
        put('f', 15);
    }};

    public static void main(String[] args) throws Exception{

    }

    @Test
    public void t1_输出最后一个单词的长度() {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        while (in.hasNextLine()) { // 注意 while 处理多个 case
            String result = in.nextLine();
            String[] dds = result.split(" ");
            System.out.println(dds[dds.length-1].length());
        }
    }

    /**
     * 写出一个程序，接受一个由字母、数字和空格组成的字符串，和一个字符，
     * 然后输出输入字符串中该字符的出现次数。（不区分大小写字母）
     * 思路: Pattern.compile匹配  matcher.find()查找 然后结果统计
     */
    @Test
    public void t2_计算某字符出现次数 () {
        Scanner scanner = new Scanner(System.in);
        String string = scanner.nextLine();
        String character = scanner.nextLine();
        Pattern compile = Pattern.compile(character, Pattern.CASE_INSENSITIVE);
        Matcher matcher = compile.matcher(string);
        int count = 0;
        while (matcher.find()) {
            count++;
        }
        System.out.println(count);
    }

    /**
     * 题:写出一个程序，接受一个由字母、数字和空格组成的字符串，和一个字符，然后输出输入字符串中该字符的出现次数。
     * 思路：这不就是TreeSet的数据结构嘛！
     */
    @Test
    public void t3_明明的随机数() {
        Scanner sc = new Scanner(System.in);
        //获取个数
        int num = sc.nextInt();
        //创建TreeSet进行去重排序
        TreeSet set = new TreeSet();
        //输入
        for(int i =0 ; i < num ;i++){
            set.add(sc.nextInt());
        }
        //输出
        Iterator iterator = set.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }

    /**
     * 题:输入一个字符串，请按长度为8拆分每个输入字符串并进行输出；
     * •长度不是8整数倍的字符串请在后面补数字0，空字符串不处理。
     * 思路:
     需要输入字符串，用到Scanner和hasNext()。
     （1）建立 Scanner sc = new Scanner(System.in);
     （2）判断有无输入用sc.hasNext().接收字符串使用sc.nextLine().
     一次性接受全部的字符串，对8取余，获知需要补0的位数。使用StringBuilder中的append()函数进行字符串修改，别忘了toString()。
     字符串缓冲区的建立：StringBuilder sb = new StringBuilder();
     输出时，截取前8位进行输出，并更新字符串。用到str.substring()函数：
     （1）str.substring(i)意为截取从字符索引第i位到末尾的字符串。
     （2）str.substring(i,j)意为截取索引第i位到第（j-1）位字符串。包含i，不包含j。
     */
    @Test
    public void t4_字符串截取() {
        Scanner sc = new Scanner(System.in);
        while(sc.hasNext()){
            String str = sc.nextLine();
            StringBuilder sb = new StringBuilder();//牢记字符串缓冲区的建立语法
            sb.append(str);//字符串缓冲区的加入
            int size = str.length();
            int addZero = 8 - size%8;//addzero的可能值包括8
            while((addZero > 0)&&(addZero<8)){//注意边界调节，避免addzero=8
                sb.append("0");//使用‘’或“”都可
                addZero--;
            }
            String str1 = sb.toString();
            while(str1.length()>0){
                System.out.println(str1.substring(0,8));
                str1 = str1.substring(8);
            }
        }
    }

    /**
     * 题:写出一个程序，接受一个十六进制的数，输出该数值的十进制表示。
     * 数据范围：保证结果在 1≤n≤231−1 1≤n≤231−1
     */
    @Test
    public void t5_进制转换Integer() {
        Scanner sc = new Scanner(System.in);
        while(sc.hasNextLine()){
            String s = sc.nextLine();
            System.out.println(Integer.parseInt(s.substring(2,s.length()),16));
        }
    }

    public static int getDecimal(String number) {
        int res = 0;
        for (char ch : number.toCharArray()) {
            res = res * BASE + map.get(ch);
        }
        return res;
    }

    @Test
    public void t6_进制转换手动() {
        Scanner in = new Scanner(System.in);
        while (in.hasNext()) {
            String number = in.next();
            int res = getDecimal(number.substring(2));
            System.out.println(res);
        }
    }

    /**
     * 输入一个正整数，按照从小到大的顺序输出它的所有质因子（重复的也要列举）（如180的质因子为2 2 3 3 5 ）
     */
    @Test
    public void t7_质数因子() {
        Scanner scanner = new Scanner(System.in);
        long num = scanner.nextLong();
        for (long i = 2; i <= num; ++i) {
            while (num % i == 0) {
                System.out.print(i + " ");
                num /= i;
            }
        }
        System.out.println();
    }

    /**
     * 写出一个程序，接受一个正浮点数值，输出该数值的近似整数值。如果小数点后数值大于等于 0.5 ,向上取整；
     * 小于 0.5 ，则向下取整。
     */
    @Test
    public void t8_取近似值() {
        Scanner in = new Scanner(System.in);
        double number = in.nextDouble();
        System.out.println((int)(number + 0.5));
    }

    /**
     * 数据表记录包含表索引index和数值value（int范围的正整数），请对表索引相同的记录进行合并，
     * 即将相同索引的数值进行求和运算，输出按照index值升序进行输出。
     * tip: 这个采用hash表存放数据就好了，每次输入查询是否有存在的key，存在就将value累加到表中，最后输出表。
     */
    @Test
    public void t9_合并表记录 () {
        Scanner scanner = new Scanner(System.in);
        int tableSize = scanner.nextInt();
        Map<Integer, Integer> table = new HashMap<>(tableSize);
        for (int i = 0; i < tableSize; i++) {
            int key = scanner.nextInt();
            int value = scanner.nextInt();
            if (table.containsKey(key)) {
                table.put(key, table.get(key) + value);
            } else {
                table.put(key, value);
            }
        }
        for (Integer key : table.keySet()) {
            System.out.println( key + " " + table.get(key));
        }

    }

    /**
     *  输入一个 int 型整数，按照从右向左的阅读顺序，返回一个不含重复数字的新的整数。
     * 保证输入的整数最后一位不是 0 。
     * 数据范围： 1≤n≤108 1≤n≤108
     * tips:StringBuilder逆序排列 reverse()
     */
    @Test
    public void tA_提取不重复的整数() {
        Scanner scanner = new Scanner(System.in);
        //逆序排列
        StringBuilder stringBuilder = new StringBuilder(scanner.nextLine()).reverse();
        String str = stringBuilder.toString();
        //结果集
        StringBuilder result = new StringBuilder();
        for (int i = 0; i < str.length(); i++) {
            if (str.indexOf(str.charAt(i)) == i) {
                result.append(str.charAt(i));
            }
        }
        System.out.println(result);
    }

    /**
     * 同提取不重复的整数的思想，charAt字符第一次出现的位置即是循环遍历索引
     */
    @Test
    public void tB_字符个数统计() {
        Scanner scanner = new Scanner(System.in);
        StringBuilder stringBuilder = new StringBuilder(scanner.nextLine());
        String str = stringBuilder.toString();
        int count = 0; //个数统计
        for (int i = 0; i < str.length(); i++) {
            if (str.indexOf(str.charAt(i)) == i) {
                count++;
            }
        }
        System.out.println(count);
    }

    /**
     * 将一个英文语句以单词为单位逆序排放。例如“I am a boy”，逆序排放后为“boy a am I”
     * 所有单词之间用一个空格隔开，语句中除了英文字母外，不再包含其他字符
     */
    @Test
    public void tC_句子逆序() {
        Scanner in=new Scanner(System.in);
        String str=in.nextLine();
        String s[]=str.split(" ");
        for(int i=s.length-1;i>=0;i--)
            if(i!=0)
                System.out.print(s[i]+" ");
            else
                System.out.println(s[i]);
    }

    /**
     *
     */
    @Test
    public void tD_字符串排序() {
        Scanner sc = new Scanner(System.in);
        while (sc.hasNext()){
            int n = sc.nextInt();
            String [] arr = new String[n];
            for(int i=0;i<n;i++){
                String str = sc.next();
                arr[i] = str;
            }
            Arrays.sort(arr);
            for(int i=0;i<arr.length;i++){
                System.out.println(arr[i]);
            }
        }
        sc.close();
    }

    /**
     *
     */
    @Test
    public void tE_() {


    }

    /**
     *
     */
    @Test
    public void tF_() {


    }

    /**
     *
     */
    @Test
    public void tF_1() {

    }

    /**
     *
     */
    @Test
    public void tF_2() {

    }

    /**
     *
     */
    @Test
    public void tF_3() {

    }

    /**
     *
     */
    @Test
    public void tF_4() {

    }

    /**
     *
     */
    @Test
    public void tF_5() {

    }

    /**
     *
     */
    @Test
    public void tF_F() {

    }

    /**
     *
     */
    @Test
    public void tF_F1() {

    }


}
